﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Objects;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Collections;


namespace DiscountsDAL
{
    public class DiscountsData
    {
        Farmin2008Entities db;

        public DiscountsData()
        {
            db = new Farmin2008Entities();
        }

        public List<T_Action> SelectActionNoDeleted()
        {
            List<T_Action> rez = (from tAct in db.T_Action
                              orderby tAct.A_Name
                              select tAct).ToList();
                             
            return rez; 
        }

        /// <summary>
        /// Получить запись из T_Action по Guid
        /// </summary>
        /// <param name="uid">guid записи</param>
        /// <returns></returns>
        public T_Action SelectActionByUid(Guid uid)
        {
            return db.T_Action.FirstOrDefault(d => d.A_Guid == uid);
        }


        public void InsertAction(T_Action tAction)
        {
            //db.AddToT_Action(tAction); // старый, но рабочий вариант
            db.T_Action.AddObject(tAction);
        }

        public void DeleteAction(Guid uidAction)
        {
            // На самом деле запись не удаляем, а просто устанавливаем флаг, что запись считается удаленной

            T_Action tAction= SelectActionByUid(uidAction);
            tAction.A_IsDelete = true;
        }



        public List<String> SelectGroupList()
        {
            return db.whGoods.Select(o => o.Группа).Distinct().OrderBy(o => o).ToList();
        }

        /// <summary>
        /// Получить значение из T_Action.A_PaternGroup
        /// </summary>
        /// <param name="uidAction">guid акции</param>
        /// <returns></returns>
        public System.String SelectPatternStrForGroup(System.Guid uidAction)
        {
            string sPaternGroup = (from tAct in db.T_Action
                                   where tAct.A_Guid == uidAction
                                   select tAct.A_PaternGroup).FirstOrDefault();

            return sPaternGroup;
        }


        public int SelectProducerIdByUid(System.Guid uidProd)
        {
            int iProdId = 0;
            iProdId = (from tProd in db.dcProducers
                       where tProd.UId == uidProd
                       select tProd.dcProducer_ID).FirstOrDefault();

            return iProdId;
        }

        public List<string> SelectEntityGroupList(Guid uidAction)
        {
            List<string> lstGroupName = (from tGroup in db.T_Group
                                         where tGroup.A_Guid == uidAction
                                         select tGroup.Group_Name).ToList();

            return lstGroupName;
        }

        public List<String> SelectSubGroupList()
        {
            //return db.GetSubGroupList().ToList(); //возвращаемое значение в методе: public List<Ct_SubGroup> SelectSubGroupList()
            return db.whGoods.Select(o => o.Подгруппа).Distinct().OrderBy(o => o).ToList();
        }

        public int SelectCountSubGroupByUid(Guid uid)
        {
            int count = 0;
            count = db.T_SubGroup.Count(d => d.A_Guid == uid);

            return count;
        }


        /// <summary>
        /// Получить значение из T_Action.A_PaternSubGroup
        /// </summary>
        /// <param name="uidAction">guid акции</param>
        /// <returns></returns>
        public System.String SelectPatternStrForSubGroup(System.Guid uidAction)
        {
            return (from tAct in db.T_Action
                    where tAct.A_Guid == uidAction
                    select tAct.A_PaternSubGroup).FirstOrDefault();   
        }

        public List<string> SelectEntitySubGroupList(Guid uidAction)
        {
            List<string> lstSubGroupName = (from tSubGroup in db.T_SubGroup
                                            where tSubGroup.A_Guid == uidAction
                                            select tSubGroup.SubGroup_Name).ToList();
            return lstSubGroupName;
        }

        public List<String> SelectTradeMarkList()
        {
            return db.whGoods.Select(o => o.ТорговаяМарка).Distinct().OrderBy(o => o).ToList();
        }


        /// <summary>
        /// Получить значение из T_Action.A_PaternTradeMark
        /// </summary>
        /// <param name="uidAction">guid акции</param>
        /// <returns></returns>
        public System.String SelectPatternTradeMark(System.Guid uidAction)
        {
            return (from tAct in db.T_Action
                    where tAct.A_Guid == uidAction
                    select tAct.A_PaternTradeMark).FirstOrDefault();
        }

        public List<string> SelectEntityTrademarkList(Guid uidAction)
        {
            List<string> lstTrademark = (from tTrademark in db.T_TradeMark
                                         where tTrademark.A_Guid == uidAction
                                         select tTrademark.Trademark_Name).ToList();
            return lstTrademark;
        }

        public List<Guid> SelectEntityProducerList(Guid uidAction)
        {
            List<Guid> lstProducer = (from tProducer in db.T_Producer
                                        where tProducer.A_Guid == uidAction
                                        select tProducer.Producer_Uid).ToList();
            return lstProducer;
        }

        public int SelectCountTradeMarkByUid(Guid uid)
        {
            int count = 0;
            count = db.T_TradeMark.Count(d => d.A_Guid == uid);

            return count;
        }

        public int SelectCountProducerByUid(Guid uid)
        {
            int count = 0;
            count = db.T_Producer.Count(d => d.A_Guid == uid);

            return count;
        }

        public List<String> SelectLineList()
        {
            //var temp = db.whGoods.Select(a => a.Линия).Distinct().OrderBy(a => a).ToList();
            return db.whGoods.Select(a => a.Линия).Distinct().OrderBy(a=>a).ToList();
        }

        public List<string> SelectEntityLineList(Guid uidAction)
        {
            List<string> lstLine = (from tLine in db.T_Line
                                    where tLine.A_Guid == uidAction
                                    select tLine.Line_Name).ToList();
            return lstLine;
        }

        public int SelectCountLineByUid(Guid uid)
        {
            int count = 0;
            count = db.T_Line.Count(d => d.A_Guid == uid);

            return count;
        }

        /// <summary>
        /// Получить значение из T_Action.A_PaternLine
        /// </summary>
        /// <param name="uidAction">guid акции</param>
        /// <returns></returns>
        public System.String SelectPatternLine(System.Guid uidAction)
        {
            return (from tAct in db.T_Action
                    where tAct.A_Guid == uidAction
                    select tAct.A_PaternLine).FirstOrDefault();
        }


        public IEnumerable SelectInternalGroupList()
        {
            #region old
            /*List<Tuple<int, int, string>>*/

            //var list = from whG in db.whGroups 
            //           select new { whG.whGroup_ID, whG.whGroup_NO, whG.whGroup_name };

            /*List<Tuple<int, int, string>>*/
            // через кортежи
            #endregion old

            IEnumerable rez = from whG in db.whGroups
                              orderby whG.whGroup_name
                              select new { Group_ID=whG.whGroup_ID, Group_NO=whG.whGroup_NO, Group_Name=whG.whGroup_name } ;

            return rez; //(IEnumerable)rez;
        }

        /// <summary>
        /// Получить значение из T_Action.A_PaternInternalGroup
        /// </summary>
        /// <param name="uidAction">guid акции</param>
        /// <returns></returns>
        public System.String SelectPatternInternalGroup(System.Guid uidAction)
        {
            return (from tAct in db.T_Action
                    where tAct.A_Guid == uidAction
                    select tAct.A_PaternInternalGroup).FirstOrDefault();
        }

        public IEnumerable SelectProducerList()
        {
            IEnumerable lstProd;

            lstProd = from dcProc in db.dcProducers
                       orderby dcProc.dcProducer_name
                       select new
                               {
                                   Producer_ID = dcProc.dcProducer_ID,
                                   Producer_name = dcProc.dcProducer_name,
                                   Producer_No = dcProc.dcProducer_NO,
                                   Producer_Uid = dcProc.UId
                               };
            return lstProd;
        }

        //public /*List<dcProducer>*/ /*IEnumerable*/ List<Tuple<int, string, int, string>> SelectProducerList()
        //{
        //    List<Tuple<int, string, int, string>> lstProducer= new List<Tuple<int, string, int, string>>();
            
        //    //dcProducer rez;

        //    List<dcProducer> lstProd;


        //    lstProd = (from dcProc in db.dcProducers
        //                    orderby dcProc.dcProducer_name
        //                    select dcProc).Cast<dcProducer>().ToList(); //new { Producer_ID = dcProc.dcProducer_ID, Producer_name = dcProc.dcProducer_name, Producer_No = dcProc.dcProducer_NO, Producer_Uid = dcProc.UId })  .Cast<Tuple<int, string, int, System.Guid>>().ToList();


        //    foreach (dcProducer dcProd in lstProd)
        //    {
        //       // new Tuple<int, string>(1, "cow" )
        //        lstProducer.Add (new Tuple<int, string, int, string>(dcProd.dcProducer_ID,dcProd.dcProducer_name,dcProd.dcProducer_NO, dcProd.UId.ToString()));//<int, string, int, Guid>(dcProd.dcProducer_ID,dcProd.dcProducer_name,dcProd.dcProducer_NO, dcProd.UId)) //(dcProd.dcProducer_ID,dcProd.dcProducer_name,dcProd.dcProducer_NO, dcProd.UId);
        //    }

        //    return lstProducer;

        //    //IEnumerable rez = from dcProc in db.dcProducers
        //    //                  orderby dcProc.dcProducer_name
        //    //                  select /*dcProc;*/ new { Producer_ID = dcProc.dcProducer_ID, Producer_name = dcProc.dcProducer_name, Producer_No=dcProc.dcProducer_NO, Producer_Uid= dcProc.UId };

        //    //List<IEnumerable> lstEnItem = new List<IEnumerable>();

        //    //foreach (var item in lstProd)
        //    //{
        //    //    lstEnItem.Add(item.dcProducer_ID);
        //    //    //item.UId
        //    //}

        //    //return rez;
        //}

        /// <summary>
        /// Получить значение из T_Action.A_PaternProducerGroup
        /// </summary>
        /// <param name="uidAction">guid акции</param>
        /// <returns></returns>
        public System.String SelectPatternProducer(System.Guid uidAction)
        {
            return (from tAct in db.T_Action
                    where tAct.A_Guid == uidAction
                    select tAct.A_PaternProducerGroup).FirstOrDefault(); 
        }


        public IEnumerable SelectPharmacyList()
        {
            // ориганальный вариант
            //IEnumerable rez = from tPharm in db.T_Pharmacy
            //                  where tPharm.Pharmacy_IsVisible == true
            //                  orderby tPharm.Pharmacy_NO
            //                  select tPharm;
            //select new { Pharm_Guid = tPharm.Pharmacy_Guid, Pharm_Name = tPharm.Pharmacy_Name + "–" + tPharm.Pharmacy_Address };
            IEnumerable rez = from tPharm in db.T_Pharmacy
                              select tPharm;


            // Этот фрагмент возвращает дублированные записи
            // Join 
            //IEnumerable rez = from tPharm in db.T_Pharmacy
            //                  join tPharmDisLink in db.T_PharmDiscountLinkLink on tPharm.Pharmacy_Guid equals tPharmDisLink.Pharmacy_Guid into myTemp
            //                  from temp in myTemp.DefaultIfEmpty() //.Select(a=>a.PDLL_Guid==null).Sum() //where temp.PDLL_Guid==null select temp.PDLL_Guid
            //                  select tPharm;
            //                  //select new { tPharm /*, temp.Temp_Guid*/ };
            


                              //from tPharmDisLink in db.T_PharmDiscountLinkLink
                              //where tPharm.Pharmacy_IsVisible == true
                              //orderby tPharm.Pharmacy_NO
                              //select tPharm;
            return rez;
        }

        /// <summary>
        /// Получить РТТ(аптеки, магазины) по GUID акции
        /// </summary>
        /// <param name="uidAction">GUID акции</param>
        /// <returns></returns>
        public IEnumerable SelectPharmacyList(System.Guid uidAction)
        {
            IQueryable<T_Pharmacy> lstPharm;

            lstPharm = from tPh in db.T_Pharmacy
                       from tPhDLL in db.T_PharmDiscountLinkLink
                       //from tGdl in db.T_GoodDiscountLink
                       from tAct in db.T_Action
                       orderby tPh.Pharmacy_NO
                       where
                           tAct.A_Guid == uidAction
                           && tAct.A_Guid ==tPhDLL.A_Guid
                           //&& tAct.A_Guid == tGdl.A_Guid
                           //&& tGdl.GDL_Guid == tPhDLL.GDL_Guid
                           && tPhDLL.Pharmacy_Guid == tPh.Pharmacy_Guid
                       select tPh;

            return lstPharm;
        }

        /// <summary>
        /// Получить Guid РТТ(аптеки, магазины) по GUID акции
        /// </summary>
        /// <param name="uidAction">GUID акции</param>
        /// <returns></returns>
        public List<Guid> SelectPatternGuidForPharmacy(System.Guid uidAction)
        {
            List<Guid> lstPharm;

            lstPharm = (from tPh in db.T_Pharmacy
                       from tPhDLL in db.T_PharmDiscountLinkLink
                       //from tGdl in db.T_GoodDiscountLink
                       from tAct in db.T_Action
                       orderby tPh.Pharmacy_NO
                       where
                           tAct.A_Guid == uidAction
                           && tAct.A_Guid == tPhDLL.A_Guid
                           && tPhDLL.Pharmacy_Guid == tPh.Pharmacy_Guid
                           //tAct.A_Guid == uidAction
                           //&& tAct.A_Guid == tGdl.A_Guid
                           //&& tGdl.GDL_Guid == tPhDLL.GDL_Guid
                           //&& tPhDLL.Pharmacy_Guid == tPh.Pharmacy_Guid
                       select tPh.Pharmacy_Guid).ToList();

            return lstPharm;
        }


        public IQueryable SelectPreSelectdProduct(System.Guid uidSession, bool bIsStock)
        {
            //IEnumerable rez = null;
            
            IQueryable<whGood> listWhGood;
            //IQueryable listWhGood;
            bool bExists=false;

            #region Old
            //rez = from whG in db.whGoods
            //      from grtmp in db.T_GroupTemp
            //      where whG.Группа == grtmp.GroupName
            //        orderby whG.whGood_name
            //        select new { Good_Name = whG.whGood_name };

            //----------------------------------------------------------------------
            

            // выбираем все позиции.
            // Когда будет определённость с полями, переписать чтобы выбирались только нужные поля
            //listWhGood = (from whG in db.whGoods
            //              orderby whG.whGood_name
            //              select whG).ToList();  //new { Good_Name = whG.whGood_name }) ;
            //---------
            #endregion

            // Общая выборка (выбираем все позиции)
            listWhGood = from whG in db.whGoods
                         orderby whG.whGood_name
                         select whG;

            // Группа
            bExists = db.T_GroupTemp.Any(u => u.IdSession == uidSession); // проверяем есть ли записи (аналог if exists в t-sql)
            if (bExists)
            {
                //if (bIsStock)
                //{
                    // т.к. остаток расчитывается, это происходит очень медленно

                   // listWhGood = from whG in listWhGood
                   //              from grtmp in db.T_GroupTemp
                   //                from whSuppl in db.whSupplies
                   //                from whSupplyItm in db.whSupplyItems
                   //              where whG.Группа == grtmp.GroupName && grtmp.IdSession == uidSession 
                   //                && whG.whGood_ID==whSuppl.whSupply_whGood_ID
                   //                && whSuppl.whSupply_ID == whSupplyItm.whSupplyItem_whSupply_ID
                   //                && (((whSupplyItm.whSupplyItem_quantity - whSupplyItm.whSupplyItem_reserved) * whG.whGood_quantity_parts) + 0.5) > 0.000001
                   //              orderby whG.whGood_name
                   //              select whG;

                   //int a= listWhGood.Count();
                //}
                //else
                //{
                    listWhGood = from whG in listWhGood
                                 from grtmp in db.T_GroupTemp
                                 where whG.Группа == grtmp.GroupName && grtmp.IdSession == uidSession
                                 orderby whG.whGood_name
                                 select whG;
                    //int b = listWhGood.Count();
                //}

                #region old
                //listWhGood = (from whG in listWhGood
                //             from grtmp in db.T_GroupTemp
                //             where whG.Группа == grtmp.GroupName
                //             orderby whG.whGood_name
                //             select whG).ToList(); // new { Good_Name = whG.whGood_name };
                
                //rez = from whG in db.whGoods
                //      from grtmp in db.T_GroupTemp
                //      where whG.Группа == grtmp.GroupName
                //      orderby whG.whGood_name
                //      select new { Good_Name = whG.whGood_name };

                //List<whGood> rez2 = (from whG in db.whGoods
                //      from grtmp in db.T_GroupTemp
                //      where whG.Группа == grtmp.GroupName
                //      orderby whG.whGood_name
                //      select whG).ToList();  //new { Good_Name = whG.whGood_name }) ;
               

                //все данные собраны, например, в rez2, а затем их нужно отфильтровать

                //var yy = (from a in rez2
                //          select a).Take(3); // вот здесь можно рабоать с данным из rez2 при помощи linq как будто это таблица
                #endregion
            }

            // Торговая марка
            bExists = db.T_TradeMarkTemp.Any(u => u.IdSession == uidSession);
            if (bExists)
            {
                listWhGood =  from whG in listWhGood
                              from trMarktmp in db.T_TradeMarkTemp
                              where whG.ТорговаяМарка == trMarktmp.TradeMark && trMarktmp.IdSession == uidSession
                              orderby whG.whGood_name
                              select whG;
                              //select new { Good_Name = whG.whGood_name };
            }

            // Подгруппа
            bExists = db.T_SubGroupTemp.Any(u => u.IdSession == uidSession);
            if (bExists)
            {
                listWhGood = from whG in listWhGood
                             from trSubGrtmp in db.T_SubGroupTemp
                             where whG.Подгруппа == trSubGrtmp.SubGroupName && trSubGrtmp.IdSession == uidSession
                             orderby whG.whGood_name
                             select whG;
            }

            // Линия
            bExists = db.T_LineTemp.Any(u => u.IdSession == uidSession);
            if (bExists)
            {
                listWhGood = from whG in listWhGood
                             from tLinetmp in db.T_LineTemp
                             where whG.Линия == tLinetmp.Line && tLinetmp.IdSession == uidSession
                             orderby whG.whGood_name
                             select whG;
            }

            // Внутреняя группа
            bExists = db.T_InternalGroupTemp.Any(u => u.IdSession == uidSession);
            if (bExists)
            {
                listWhGood = from whG in listWhGood
                             from tIntGrtmp in db.T_InternalGroupTemp
                             where whG.whGood_whGroup_ID == tIntGrtmp.Group_Id && tIntGrtmp.IdSession == uidSession
                             orderby whG.whGood_name
                             select whG;
                             //select new { Good_Name = whG.whGood_name };
            }

            // Производитель
            bExists = db.T_ProducerTemp.Any(u => u.IdSession == uidSession);
            if (bExists)
            {
                listWhGood = from whG in listWhGood
                             from tProdtmp in db.T_ProducerTemp
                             where whG.whGood_dcProducer_ID == tProdtmp.Producer_Id 
                                    && tProdtmp.IdSession == uidSession 
                                   //---
                                    //&& 
                                    //---
                             orderby whG.whGood_name
                             select whG;
                //select new { Good_Name = whG.whGood_name };
            }




            //rez = from whG in db.whGoods
            //      join grtmp in db.T_GroupTemp
            //      on whG.Группа equals grtmp.GroupName
            //      orderby whG.whGood_name
            //      select new { Good_Name = whG.whGood_name };


            return listWhGood; //rez; /* возвращался в этом случии IEnumerable*/ 
        }


        #region CRUD T_SubGroup

        /// <summary>
        /// Получить запись из T_SubGroup по Guid
        /// </summary>
        /// <param name="uid">guid записи</param>
        /// <returns></returns>
        public T_SubGroup SelectSubGroupByUid(Guid uid)
        {
            return db.T_SubGroup.FirstOrDefault(d => d.A_Guid == uid);
        }

        /// <summary>
        /// Удалить объект в T_SubGroup
        /// </summary>
        /// <param name="tSubGroup">переменная типа T_Group</param>
        public void DeleteT_SubGroup(T_SubGroup tSubGroup)
        {
            db.T_SubGroup.Attach(tSubGroup);       // подключаем объект в контекст
            db.T_SubGroup.DeleteObject(tSubGroup); // 'помечаем' на удаление (реально удалаяется только при сохранении изминений)
        }

        /// <summary>
        /// Вставить объект в T_SubGroup
        /// </summary>
        /// <param name="tSubGroup"></param>
        public void InsertT_SubGroup(T_SubGroup tSubGroup)
        {
            db.T_SubGroup.AddObject(tSubGroup);
        }

        #endregion

        #region CRUD T_Group

        /// <summary>
        /// Получить запись из T_Group по Guid
        /// </summary>
        /// <param name="uid">guid записи</param>
        /// <returns></returns>
        public T_Group SelectGroupByUid(Guid uid)
        {
            return db.T_Group.FirstOrDefault(d => d.A_Guid == uid);
        }



        public int SelectCountGroupByUid(Guid uid)
        {
            int count = 0;
            count= db.T_Group.Count(d => d.A_Guid == uid);

            return count;
        }

       
        /// <summary>
        /// Вставить объект в T_Group
        /// </summary>
        /// <param name="tGroup"></param>
        public void InsertT_Group(T_Group tGroup)
        {
            db.T_Group.AddObject(tGroup);
        }

        /// <summary>
        /// Удалить объект в T_Group
        /// </summary>
        /// <param name="tGroup">переменная типа T_Group</param>
        public void DeleteT_Group(T_Group tGroup)
        {
            db.T_Group.Attach(tGroup);       // подключаем объект T_GroupTemp в контекст
            db.T_Group.DeleteObject(tGroup); // 'помечаем' на удаление (реально удалаяется только при сохранении изминений)
        }

        #endregion

        #region T_Line

        /// <summary>
        /// Получить запись из T_Line по Guid
        /// </summary>
        /// <param name="uid">guid записи</param>
        /// <returns></returns>
        public T_Line SelectLineByUid(Guid uid)
        {
            return db.T_Line.FirstOrDefault(d => d.A_Guid == uid);
        }

        /// <summary>
        /// Удалить объект в T_Line
        /// </summary>
        /// <param name="tLine">переменная типа T_Line</param>
        public void DeleteT_Line(T_Line tLine)
        {
            db.T_Line.Attach(tLine);       // подключаем объект в контекст
            db.T_Line.DeleteObject(tLine); // 'помечаем' на удаление (реально удалаяется только при сохранении изминений)
        }

        /// <summary>
        /// Вставить объект в T_Line
        /// </summary>
        /// <param name="tLine"></param>
        public void InsertT_Line(T_Line tLine)
        {
            db.T_Line.AddObject(tLine);
        }

        #endregion

        #region CRUD T_GroupTemp

        /// <summary>
        /// Вставить объект в T_GroupTemp 
        /// </summary>
        /// <param name="GrTmp">переменная типа T_GroupTemp</param>
        public void InsertT_GroupTemp(T_GroupTemp GrTmp)
        {
            db.T_GroupTemp.AddObject(GrTmp);
        }
        /// <summary>
        /// Удалить объект в T_GroupTemp
        /// </summary>
        /// <param name="GrTmp">переменная типа T_GroupTemp</param>
        public void DeleteT_GroupTemp(T_GroupTemp GrTmp)
        {
            db.T_GroupTemp.Attach(GrTmp);       // подключаем объект T_GroupTemp в контекст
            db.T_GroupTemp.DeleteObject(GrTmp); // 'помечаем' на удаление (реально удалаяется только при сохранении изминений)
        }

        #endregion


        #region CRUD T_Producer
        
        /// <summary>
        /// Получить запись из T_Producer по Guid
        /// </summary>
        /// <param name="uid">guid записи</param>
        /// <returns></returns>
        public T_Producer SelectProducerByUid(Guid uid)
        {
            return db.T_Producer.FirstOrDefault(d => d.A_Guid == uid);
        }

        /// <summary>
        /// Вставить объект в T_TradeMark
        /// </summary>
        /// <param name="tProducer"></param>
        public void InsertT_Producer(T_Producer tProducer)
        {
            db.T_Producer.AddObject(tProducer);
        }

        /// <summary>
        /// Удалить объект в T_Producer
        /// </summary>
        /// <param name="tProducer">переменная типа T_TradeMark</param>
        public void DeleteT_Producer(T_Producer tProducer)
        {
            db.T_Producer.Attach(tProducer);       // подключаем объект в контекст
            db.T_Producer.DeleteObject(tProducer); // 'помечаем' на удаление (реально удалаяется только при сохранении изминений)
        }


        #endregion

        #region CRUD T_TradeMark
        /// <summary>
        /// Получить запись из T_TradeMark по Guid
        /// </summary>
        /// <param name="uid">guid записи</param>
        /// <returns></returns>
        public T_TradeMark SelectTradeMarkByUid(Guid uid)
        {
            return db.T_TradeMark.FirstOrDefault(d => d.A_Guid == uid);
        }

        /// <summary>
        /// Удалить объект в T_TradeMark
        /// </summary>
        /// <param name="tTradeMark">переменная типа T_TradeMark</param>
        public void DeleteT_TradeMark(T_TradeMark tTradeMark)
        {
            db.T_TradeMark.Attach(tTradeMark);       // подключаем объект в контекст
            db.T_TradeMark.DeleteObject(tTradeMark); // 'помечаем' на удаление (реально удалаяется только при сохранении изминений)
        }

        /// <summary>
        /// Вставить объект в T_TradeMark
        /// </summary>
        /// <param name="tTradeMark"></param>
        public void InsertT_TradeMark(T_TradeMark tTradeMark)
        {
            db.T_TradeMark.AddObject(tTradeMark);
        }

        #endregion



        #region CRUD T_TradeMarkTemp

        /// <summary>
        /// Вставить объект в T_TradeMarkTemp
        /// </summary>
        /// <param name="GrTmp">переменная типа T_TradeMarkTemp</param>
        public void InsertT_TradeMarkTemp(T_TradeMarkTemp TmTmp)
        {
            db.T_TradeMarkTemp.AddObject(TmTmp);
        }

        /// <summary>
        /// Удалить объект в T_TradeMarkTemp
        /// </summary>
        /// <param name="GrTmp">переменная типа T_TradeMarkTemp</param>
        public void DeleteT_TradeMarkTemp(T_TradeMarkTemp TmTmp)
        {
            db.T_TradeMarkTemp.Attach(TmTmp);
            db.T_TradeMarkTemp.DeleteObject(TmTmp); 
        }

        #endregion

        #region CRUD T_SubGroupTemp

        /// <summary>
        /// Вставить объект в T_SubGroupTemp 
        /// </summary>
        /// <param name="SubGrTmp">переменная типа T_SubGroupTemp</param>
        public void InsertT_SubGroupTemp(T_SubGroupTemp SubGrTmp)
        {
            db.T_SubGroupTemp.AddObject(SubGrTmp);
        }

        /// <summary>
        /// Удалить объект в T_SubGroupTemp
        /// </summary>
        /// <param name="SubGrTmp">переменная типа T_SubGroupTemp</param>
        public void DeleteT_SubGroupTemp(T_SubGroupTemp SubGrTmp)
        {
            db.T_SubGroupTemp.Attach(SubGrTmp);
            db.T_SubGroupTemp.DeleteObject(SubGrTmp);
        }

        #endregion



        #region CRUD T_LineTemp

        /// <summary>
        /// Вставить объект в T_LineTemp 
        /// </summary>
        /// <param name="LineTmp">переменная типа T_LineTemp</param>
        public void InsertT_LineTemp(T_LineTemp LineTmp)
        {
            db.T_LineTemp.AddObject(LineTmp);
        }

        /// <summary>
        /// Удалить объект в T_LineTemp
        /// </summary>
        /// <param name="LineTmp">переменная типа T_LineTemp</param>
        public void DeleteT_LineTemp(T_LineTemp LineTmp)
        {
            db.T_LineTemp.Attach(LineTmp);
            db.T_LineTemp.DeleteObject(LineTmp);
        }

        #endregion

        #region CRUD T_InternalGroupTemp

        /// <summary>
        /// Вставить объект в T_InternalGroupTemp 
        /// </summary>
        /// <param name="InternalGrTmp">переменная типа T_InternalGroupTemp</param>
        public void InsertT_InternalGroupTemp(T_InternalGroupTemp InternalGrTmp)
        {
            db.T_InternalGroupTemp.AddObject(InternalGrTmp);
        }

        /// <summary>
        /// Удалить объект в T_InternalGroupTemp
        /// </summary>
        /// <param name="InternalGrTmp">переменная типа T_InternalGroupTemp</param>
        public void DeleteT_InternalGroupTemp(T_InternalGroupTemp InternalGrTmp)
        {
            db.T_InternalGroupTemp.Attach(InternalGrTmp);
            db.T_InternalGroupTemp.DeleteObject(InternalGrTmp);
        }

        #endregion

        #region CRUD T_ProducerTemp

        /// <summary>
        /// Вставить объект в T_ProducerTemp 
        /// </summary>
        /// <param name="ProducerTmp">переменная типа T_ProducerTemp</param>
        public void InsertT_ProducerTemp(T_ProducerTemp ProducerTmp)
        {
            db.T_ProducerTemp.AddObject(ProducerTmp);
        }

        /// <summary>
        /// Удалить объект в T_ProducerTemp
        /// </summary>
        /// <param name="ProducerTmp">переменная типа T_ProducerTemp</param>
        public void DeleteT_ProducerTemp(T_ProducerTemp ProducerTmp)
        {
            db.T_ProducerTemp.Attach(ProducerTmp);
            db.T_ProducerTemp.DeleteObject(ProducerTmp);
        }

        #endregion

        #region CRUD T_GoodDiscountLink

        /// <summary>
        /// Вставить объект в T_GoodDiscountLink
        /// </summary>
        /// <param name="GoodDiscountLink"></param>
        public void InsertT_GoodDiscountLink(T_GoodDiscountLink GoodDiscountLink)
        {
            db.T_GoodDiscountLink.AddObject(GoodDiscountLink);
        }

        /// <summary>
        /// Удалить объект из T_GoodDiscountLink (НЕ ИСПОЛЬЗОВАТЬ)
        /// </summary>
        /// <param name="GoodDiscountLink"></param>
        //public void DeleteT_GoodDiscountLink(T_GoodDiscountLink GoodDiscountLink)
        //{
        //    // НЕ ИСПОЛЬЗОВАТЬ
        //    T_GoodDiscountLink gdl = db.T_GoodDiscountLink.First(f => f.whGood_Id == 8095);
        //    db.T_GoodDiscountLink.DeleteObject(gdl);        
        //}

        public void DeleteT_GoodDiscountLink(Guid uid)
        {
            T_GoodDiscountLink gdl = db.T_GoodDiscountLink.FirstOrDefault(i => i.whGood_Uid == uid);
            db.T_GoodDiscountLink.DeleteObject(gdl);      
        }

        /// <summary>
        /// Выбрать позицию в T_GoodDiscountLink по whGood_Uid
        /// </summary>
        /// <param name="uid">whGood_Uid</param>
        /// <returns></returns>
        public IQueryable SelectGoodDiscountLink(System.Guid uid)
        {
            IQueryable gdl;
            
            gdl = from tGdl in db.T_GoodDiscountLink
                  where tGdl.whGood_Uid == uid
                  select tGdl;

            return gdl;
        }

        public IQueryable SelectGoodDiscountLinkAndActionName()
        {
            IQueryable list;

            list = from tGdl in db.T_GoodDiscountLink
                   from tAction in db.T_Action
                   where tGdl.A_Guid == tAction.A_Guid
                   select new { whGoodUid= tGdl.whGood_Uid, Name=tAction.A_Name };

            return list;
        }

        /// <summary>
        /// Получаем GDL_Guid по whGood_Uid в таблице T_GoodDiscountLink
        /// </summary>
        /// <param name="uid">whGood_Uid</param>
        /// <returns></returns>
        public System.Guid GetGdlUidByWhGoodUid(System.Guid uid)
        {
            return db.T_GoodDiscountLink.FirstOrDefault(i => i.whGood_Uid == uid).GDL_Guid;
        }


        #endregion
        
        #region CRUD whGood

        /// <summary>
        /// Вставить объект в whGood
        /// </summary>
        /// <param name="WhGood"></param>
        public void InsertWhGood(whGood WhGood)
        {
            db.whGoods.AddObject(WhGood);
        }

        #endregion

        #region CRUD T_PharmDiscountLinkLink

        /// <summary>
        /// Проверка, есть ли такая запись (с таким guid акции и аптеки) в БД
        /// </summary>
        /// <param name="gPharmacyGuid">guid аптеки</param>
        /// <param name="gAGuid">guid акции</param>
        /// <returns></returns>
        public bool IfExistsByPharmAndAction(System.Guid gPharmacyGuid, System.Guid gAGuid)
        {
            //bool brez;
            return db.T_PharmDiscountLinkLink.Any(a => a.Pharmacy_Guid == gPharmacyGuid && a.A_Guid == gAGuid);
        }

        public Guid GetPDllGuidByActionAndPharm(System.Guid gPharmacyGuid, System.Guid gAGuid)
        {
            return (from tDLL in db.T_PharmDiscountLinkLink
                    where tDLL.Pharmacy_Guid == gPharmacyGuid
                          && tDLL.A_Guid == gAGuid
                    select tDLL.PDLL_Guid).SingleOrDefault();
        }

        /// <summary>
        /// Вставить объект в T_GoodDiscountLink
        /// </summary>
        /// <param name="PharmDiscountLinkLink"></param>
        public void InsertT_PharmDiscountLinkLink(T_PharmDiscountLinkLink PharmDiscountLinkLink)
        {
            db.T_PharmDiscountLinkLink.AddObject(PharmDiscountLinkLink);
        }

        /// <summary>
        /// Удалить объект из T_PharmDiscountLinkLink
        /// </summary>
        /// <param name="PharmDiscountLinkLink"></param>
        public void DeleteT_PharmDiscountLinkLink(T_PharmDiscountLinkLink PharmDiscountLinkLink)
        {
            db.T_PharmDiscountLinkLink.Attach(PharmDiscountLinkLink);
            db.T_PharmDiscountLinkLink.DeleteObject(PharmDiscountLinkLink);
        }

        #endregion      

        
        /// <summary>
        /// Получить товары (whGood) по GUID акции
        /// </summary>
        /// <param name="uidAction">GUID акции</param>
        /// <returns></returns>
        public IQueryable SelectGoodByAction(System.Guid uidAction)
        {
            IQueryable<whGood> listWhGood;

            listWhGood = from tGdl in db.T_GoodDiscountLink
                         from tAct in db.T_Action
                         from tWhg in db.whGoods
                         where tAct.A_Guid == uidAction && tAct.A_Guid == tGdl.A_Guid && tGdl.whGood_Id == tWhg.whGood_ID
                         orderby tWhg.whGood_name
                         select tWhg;

            return listWhGood;
        }

        #region CRUD T_DiscountCountGoods и T_LinkDCG

        /// <summary>
        /// Получить скидки (T_DiscountCountGoods) по GUID акции 
        /// </summary>
        /// <param name="uidAction">GUID акции</param>
        /// <returns></returns>
        public IQueryable SelectDiscountCountByAction(Guid uidAction)
        {
            IQueryable<T_DiscountCountGoods> lstDisCount;

            lstDisCount = from tDcg in db.T_DiscountCountGoods
                          from tLinkDCG in db.T_LinkDCG
                          from tAct in db.T_Action
                          orderby tDcg.Dcg_IsActive descending, tDcg.Dcg_PercentDiscount
                          where
                              tAct.A_Guid == uidAction
                              && tAct.A_Guid == tLinkDCG.A_Guid
                              && tLinkDCG.Dcg_Guid == tDcg.Dcg_Guid
                          select tDcg;

            return lstDisCount;
        }

        /// <summary>
        /// Получить запись из T_DiscountCountGoods по Guid
        /// </summary>
        /// <param name="uid">guid записи</param>
        /// <returns></returns>
        public T_DiscountCountGoods SelectDiscountCountByUid(Guid uid)
        {
            return db.T_DiscountCountGoods.FirstOrDefault(d => d.Dcg_Guid == uid);
        }

        /// <summary>
        /// Вставить объект в T_DiscountCountGoods
        /// </summary>
        /// <param name="DiscountCountGoods">объект типа T_DiscountCountGoods</param>
        public void InsertT_DiscountCountGoods(T_DiscountCountGoods DiscountCountGoods)
        {
            db.T_DiscountCountGoods.AddObject(DiscountCountGoods);
        }

        /// <summary>
        /// Вставить объект в T_LinkDCG
        /// </summary>
        /// <param name="LinkDCG">объект типа T_LinkDCG</param>
        public void InsertT_LinkDCG(T_LinkDCG LinkDCG)
        {
            db.T_LinkDCG.AddObject(LinkDCG);
        }

        //--------------------------------------------


        public void DeleteT_DiscountCountGoods(Guid uidDcg, Guid uidAction)
        {
            T_DiscountCountGoods tDiscountCountGoods = SelectDiscountCountByUid(uidDcg);
            db.T_DiscountCountGoods.DeleteObject(tDiscountCountGoods);

            T_LinkDCG tLinkDcg = SelectLinkDcg(uidDcg, uidAction);
            db.T_LinkDCG.DeleteObject(tLinkDcg);
        }

        public T_LinkDCG SelectLinkDcg(Guid uidDcg, Guid uidAction)
        {
            return db.T_LinkDCG.FirstOrDefault(d => d.Dcg_Guid == uidDcg && d.A_Guid == uidAction);

            //return  (from tLinkDcg in db.T_LinkDCG
            //         where tLinkDcg.Dcg_Guid == uidDcg
            //               && tLinkDcg.A_Guid == uidAction
            //         select tLinkDcg).FirstOrDefault();
        }

        #endregion







        #region CRUD T_DiscountTime и T_LinkDT

        /// <summary>
        /// Получить запись из T_DiscountTime по Guid
        /// </summary>
        /// <param name="uid">guid записи</param>
        /// <returns></returns>
        public T_DiscountTime SelectDiscountTimeByUid(Guid uid)
        {
            return db.T_DiscountTime.FirstOrDefault(d => d.Dt_Guid == uid);
        }

        /// <summary>
        /// Получаю скидку T_DiscountTime по GUID акции
        /// </summary>
        /// <param name="uidAction"></param>
        /// <returns></returns>
        public IQueryable SelectDiscountTimeByAction(System.Guid uidAction)
        {
            IQueryable<T_DiscountTime> lstDisTime;

            lstDisTime = from tDisTime in db.T_DiscountTime
                         from tLinkDT in db.T_LinkDT
                         from tAct in db.T_Action
                         orderby tDisTime.Dt_TimeBegin 
                         where tAct.A_Guid == uidAction
                               && tAct.A_Guid == tLinkDT.A_Guid
                               && tLinkDT.Dt_Guid == tDisTime.Dt_Guid
                         select tDisTime;

            return lstDisTime;
        }

        /// <summary>
        /// Вставить объект в T_DiscountTime
        /// </summary>
        /// <param name="DiscountTime">объект типа T_DiscountTime</param>
        public void InsertT_DiscountTime(T_DiscountTime DiscountTime)
        {
            db.T_DiscountTime.AddObject(DiscountTime);
        }

        /// <summary>
        /// Вставить объект в T_LinkDT
        /// </summary>
        /// <param name="LinkDT">объект типа T_LinkDCG</param>
        public void InsertT_LinkDT(T_LinkDT LinkDT)
        {
            db.T_LinkDT.AddObject(LinkDT);
        }

        public void DeleteT_DiscountTime (Guid uidDt, Guid uidAction)
        {
            T_DiscountTime tDiscountTime = SelectDiscountTimeByUid(uidDt);
            db.T_DiscountTime.DeleteObject(tDiscountTime);

            T_LinkDT tLinkDt = SelectLinkDt(uidDt, uidAction);
            db.T_LinkDT.DeleteObject(tLinkDt);
        }

        public T_LinkDT SelectLinkDt(Guid uidDt, Guid uidAction)
        {
            return db.T_LinkDT.FirstOrDefault(d => d.Dt_Guid == uidDt && d.A_Guid == uidAction);
        }

        #endregion


        #region CRUD T_GoodSupplyLink
        // T_GoodSupplyLink больше не используется 25.05.13
        /*
        /// <summary>
        /// Получить List whSupply_ID по whGoodId
        /// </summary>
        /// <param name="iWhGoodId"></param>
        /// <returns></returns>
        public List<Int32> GetSupplyIdByWhGoodId(Int32 iWhGoodId)
        {
            List<Int32> litWhSupplyId;

            litWhSupplyId = (from tWhSupply in db.whSupplies
                             where tWhSupply.whSupply_whGood_ID == iWhGoodId
                             select tWhSupply.whSupply_ID).ToList();

            return litWhSupplyId;
        }

        /// <summary>
        /// Вставить объект в T_GoodSupplyLink
        /// </summary>
        /// <param name="GoodSupplyLink"></param>
        public void InsertT_GoodSupplyLink(T_GoodSupplyLink GoodSupplyLink)
        {
            db.T_GoodSupplyLink.AddObject(GoodSupplyLink);
        }

        /// <summary>
        /// Удаляем запись из T_GoodSupplyLink
        /// </summary>
        /// <param name="uid"></param>
        public void DeleteT_GoodSupplyLink(Guid uid)
        {
            List<T_GoodSupplyLink> lstGsl = (db.T_GoodSupplyLink.Where(i => i.Gdl_Guid == uid)).ToList();

            foreach (T_GoodSupplyLink goodSupplyLink in lstGsl)
            {
                db.T_GoodSupplyLink.DeleteObject(goodSupplyLink); 
            }               
        }
        */

        #endregion






        /// <summary>
        /// Сохранить изминения в БД
        /// </summary>
        public void SaveChanges()
        {
            try
            {
                var u = db.SaveChanges();
            }
            catch (OptimisticConcurrencyException)
            {
                db.Refresh(RefreshMode.ClientWins, db.T_GoodDiscountLink );
                db.SaveChanges();
            }
            
        }

    }
}
